agora inbox for pgsql-hackers@postgresql.orghelp / color / mirror / Atom feed
[PATCH v29 10/11] Add regression tests for Incremental View Maintenance 604+ messages / 2 participants [nested] [flat]
* [PATCH v29 10/11] Add regression tests for Incremental View Maintenance @ 2021-03-10 02:11 Takuma Hoshiai <takuma.hoshiai@gmail.com> 0 siblings, 0 replies; 604+ messages in thread From: Takuma Hoshiai @ 2021-03-10 02:11 UTC (permalink / raw) --- .../regress/expected/incremental_matview.out | 1030 +++++++++++++++++ src/test/regress/parallel_schedule | 2 +- src/test/regress/sql/incremental_matview.sql | 533 +++++++++ 3 files changed, 1564 insertions(+), 1 deletion(-) create mode 100644 src/test/regress/expected/incremental_matview.out create mode 100644 src/test/regress/sql/incremental_matview.sql diff --git a/src/test/regress/expected/incremental_matview.out b/src/test/regress/expected/incremental_matview.out new file mode 100644 index 0000000000..8946d09f5d --- /dev/null +++ b/src/test/regress/expected/incremental_matview.out @@ -0,0 +1,1030 @@ +-- create a table to use as a basis for views and materialized views in various combinations +CREATE TABLE mv_base_a (i int, j int); +INSERT INTO mv_base_a VALUES + (1,10), + (2,20), + (3,30), + (4,40), + (5,50); +CREATE TABLE mv_base_b (i int, k int); +INSERT INTO mv_base_b VALUES + (1,101), + (2,102), + (3,103), + (4,104); +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_1 AS SELECT i,j,k FROM mv_base_a a INNER JOIN mv_base_b b USING(i) WITH NO DATA; +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; +ERROR: materialized view "mv_ivm_1" has not been populated +HINT: Use the REFRESH MATERIALIZED VIEW command. +REFRESH MATERIALIZED VIEW mv_ivm_1; +NOTICE: could not create an index on materialized view "mv_ivm_1" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; + i | j | k +---+----+----- + 1 | 10 | 101 + 2 | 20 | 102 + 3 | 30 | 103 + 4 | 40 | 104 +(4 rows) + +-- REFRESH WITH NO DATA +BEGIN; +CREATE FUNCTION dummy_ivm_trigger_func() RETURNS TRIGGER AS $$ + BEGIN + RETURN NULL; + END +$$ language plpgsql; +CREATE CONSTRAINT TRIGGER dummy_ivm_trigger AFTER INSERT +ON mv_base_a FROM mv_ivm_1 FOR EACH ROW +EXECUTE PROCEDURE dummy_ivm_trigger_func(); +SELECT COUNT(*) +FROM pg_depend pd INNER JOIN pg_trigger pt ON pd.objid = pt.oid +WHERE pd.classid = 'pg_trigger'::regclass AND pd.refobjid = 'mv_ivm_1'::regclass; + count +------- + 17 +(1 row) + +REFRESH MATERIALIZED VIEW mv_ivm_1 WITH NO DATA; +SELECT COUNT(*) +FROM pg_depend pd INNER JOIN pg_trigger pt ON pd.objid = pt.oid +WHERE pd.classid = 'pg_trigger'::regclass AND pd.refobjid = 'mv_ivm_1'::regclass; + count +------- + 1 +(1 row) + +ROLLBACK; +-- immediate maintenance +BEGIN; +INSERT INTO mv_base_b VALUES(5,105); +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; + i | j | k +---+----+----- + 1 | 10 | 101 + 2 | 20 | 102 + 3 | 30 | 103 + 4 | 40 | 104 + 5 | 50 | 105 +(5 rows) + +UPDATE mv_base_a SET j = 0 WHERE i = 1; +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; + i | j | k +---+----+----- + 1 | 0 | 101 + 2 | 20 | 102 + 3 | 30 | 103 + 4 | 40 | 104 + 5 | 50 | 105 +(5 rows) + +DELETE FROM mv_base_b WHERE (i,k) = (5,105); +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; + i | j | k +---+----+----- + 1 | 0 | 101 + 2 | 20 | 102 + 3 | 30 | 103 + 4 | 40 | 104 +(4 rows) + +ROLLBACK; +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; + i | j | k +---+----+----- + 1 | 10 | 101 + 2 | 20 | 102 + 3 | 30 | 103 + 4 | 40 | 104 +(4 rows) + +-- rename of IVM columns +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_rename AS SELECT DISTINCT * FROM mv_base_a; +NOTICE: created index "mv_ivm_rename_index" on materialized view "mv_ivm_rename" +ALTER MATERIALIZED VIEW mv_ivm_rename RENAME COLUMN __ivm_count__ TO xxx; +ERROR: IVM column can not be renamed +DROP MATERIALIZED VIEW mv_ivm_rename; +-- unique index on IVM columns +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_unique AS SELECT DISTINCT * FROM mv_base_a; +NOTICE: created index "mv_ivm_unique_index" on materialized view "mv_ivm_unique" +CREATE UNIQUE INDEX ON mv_ivm_unique(__ivm_count__); +ERROR: unique index creation on IVM columns is not supported +CREATE UNIQUE INDEX ON mv_ivm_unique((__ivm_count__)); +ERROR: unique index creation on IVM columns is not supported +CREATE UNIQUE INDEX ON mv_ivm_unique((__ivm_count__ + 1)); +ERROR: unique index creation on IVM columns is not supported +DROP MATERIALIZED VIEW mv_ivm_unique; +-- TRUNCATE a base table in join views +BEGIN; +TRUNCATE mv_base_a; +SELECT * FROM mv_ivm_1; + i | j | k +---+---+--- +(0 rows) + +ROLLBACK; +BEGIN; +TRUNCATE mv_base_b; +SELECT * FROM mv_ivm_1; + i | j | k +---+---+--- +(0 rows) + +ROLLBACK; +-- some query syntax +BEGIN; +CREATE FUNCTION ivm_func() RETURNS int LANGUAGE 'sql' + AS 'SELECT 1' IMMUTABLE; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_func AS SELECT * FROM ivm_func(); +NOTICE: could not create an index on materialized view "mv_ivm_func" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_no_tbl AS SELECT 1; +NOTICE: could not create an index on materialized view "mv_ivm_no_tbl" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +ROLLBACK; +-- result of materialized view have DISTINCT clause or the duplicate result. +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_duplicate AS SELECT j FROM mv_base_a; +NOTICE: could not create an index on materialized view "mv_ivm_duplicate" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_distinct AS SELECT DISTINCT j FROM mv_base_a; +NOTICE: created index "mv_ivm_distinct_index" on materialized view "mv_ivm_distinct" +INSERT INTO mv_base_a VALUES(6,20); +SELECT * FROM mv_ivm_duplicate ORDER BY 1; + j +---- + 10 + 20 + 20 + 30 + 40 + 50 +(6 rows) + +SELECT * FROM mv_ivm_distinct ORDER BY 1; + j +---- + 10 + 20 + 30 + 40 + 50 +(5 rows) + +DELETE FROM mv_base_a WHERE (i,j) = (2,20); +SELECT * FROM mv_ivm_duplicate ORDER BY 1; + j +---- + 10 + 20 + 30 + 40 + 50 +(5 rows) + +SELECT * FROM mv_ivm_distinct ORDER BY 1; + j +---- + 10 + 20 + 30 + 40 + 50 +(5 rows) + +ROLLBACK; +-- support SUM(), COUNT() and AVG() aggregate functions +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg AS SELECT i, SUM(j), COUNT(i), AVG(j) FROM mv_base_a GROUP BY i; +NOTICE: created index "mv_ivm_agg_index" on materialized view "mv_ivm_agg" +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3,4; + i | sum | count | avg +---+-----+-------+--------------------- + 1 | 10 | 1 | 10.0000000000000000 + 2 | 20 | 1 | 20.0000000000000000 + 3 | 30 | 1 | 30.0000000000000000 + 4 | 40 | 1 | 40.0000000000000000 + 5 | 50 | 1 | 50.0000000000000000 +(5 rows) + +INSERT INTO mv_base_a VALUES(2,100); +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3,4; + i | sum | count | avg +---+-----+-------+--------------------- + 1 | 10 | 1 | 10.0000000000000000 + 2 | 120 | 2 | 60.0000000000000000 + 3 | 30 | 1 | 30.0000000000000000 + 4 | 40 | 1 | 40.0000000000000000 + 5 | 50 | 1 | 50.0000000000000000 +(5 rows) + +UPDATE mv_base_a SET j = 200 WHERE (i,j) = (2,100); +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3,4; + i | sum | count | avg +---+-----+-------+---------------------- + 1 | 10 | 1 | 10.0000000000000000 + 2 | 220 | 2 | 110.0000000000000000 + 3 | 30 | 1 | 30.0000000000000000 + 4 | 40 | 1 | 40.0000000000000000 + 5 | 50 | 1 | 50.0000000000000000 +(5 rows) + +DELETE FROM mv_base_a WHERE (i,j) = (2,200); +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3,4; + i | sum | count | avg +---+-----+-------+--------------------- + 1 | 10 | 1 | 10.0000000000000000 + 2 | 20 | 1 | 20.0000000000000000 + 3 | 30 | 1 | 30.0000000000000000 + 4 | 40 | 1 | 40.0000000000000000 + 5 | 50 | 1 | 50.0000000000000000 +(5 rows) + +ROLLBACK; +-- support COUNT(*) aggregate function +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg AS SELECT i, SUM(j), COUNT(*) FROM mv_base_a GROUP BY i; +NOTICE: created index "mv_ivm_agg_index" on materialized view "mv_ivm_agg" +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3; + i | sum | count +---+-----+------- + 1 | 10 | 1 + 2 | 20 | 1 + 3 | 30 | 1 + 4 | 40 | 1 + 5 | 50 | 1 +(5 rows) + +INSERT INTO mv_base_a VALUES(2,100); +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3; + i | sum | count +---+-----+------- + 1 | 10 | 1 + 2 | 120 | 2 + 3 | 30 | 1 + 4 | 40 | 1 + 5 | 50 | 1 +(5 rows) + +ROLLBACK; +-- TRUNCATE a base table in aggregate views +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg AS SELECT i, SUM(j), COUNT(*) FROM mv_base_a GROUP BY i; +NOTICE: created index "mv_ivm_agg_index" on materialized view "mv_ivm_agg" +TRUNCATE mv_base_a; +SELECT sum, count FROM mv_ivm_agg; + sum | count +-----+------- +(0 rows) + +SELECT i, SUM(j), COUNT(*) FROM mv_base_a GROUP BY i; + i | sum | count +---+-----+------- +(0 rows) + +ROLLBACK; +-- support aggregate functions without GROUP clause +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_group AS SELECT SUM(j), COUNT(j), AVG(j) FROM mv_base_a; +NOTICE: could not create an index on materialized view "mv_ivm_group" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +SELECT * FROM mv_ivm_group ORDER BY 1; + sum | count | avg +-----+-------+--------------------- + 150 | 5 | 30.0000000000000000 +(1 row) + +INSERT INTO mv_base_a VALUES(6,60); +SELECT * FROM mv_ivm_group ORDER BY 1; + sum | count | avg +-----+-------+--------------------- + 210 | 6 | 35.0000000000000000 +(1 row) + +DELETE FROM mv_base_a; +SELECT * FROM mv_ivm_group ORDER BY 1; + sum | count | avg +-----+-------+----- + | 0 | +(1 row) + +ROLLBACK; +-- TRUNCATE a base table in aggregate views without GROUP clause +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_group AS SELECT SUM(j), COUNT(j), AVG(j) FROM mv_base_a; +NOTICE: could not create an index on materialized view "mv_ivm_group" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +TRUNCATE mv_base_a; +SELECT sum, count, avg FROM mv_ivm_group; + sum | count | avg +-----+-------+----- + | 0 | +(1 row) + +SELECT SUM(j), COUNT(j), AVG(j) FROM mv_base_a; + sum | count | avg +-----+-------+----- + | 0 | +(1 row) + +ROLLBACK; +-- resolved issue: When use AVG() function and values is indivisible, result of AVG() is incorrect. +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_avg_bug AS SELECT i, SUM(j), COUNT(j), AVG(j) FROM mv_base_A GROUP BY i; +NOTICE: created index "mv_ivm_avg_bug_index" on materialized view "mv_ivm_avg_bug" +SELECT * FROM mv_ivm_avg_bug ORDER BY 1,2,3; + i | sum | count | avg +---+-----+-------+--------------------- + 1 | 10 | 1 | 10.0000000000000000 + 2 | 20 | 1 | 20.0000000000000000 + 3 | 30 | 1 | 30.0000000000000000 + 4 | 40 | 1 | 40.0000000000000000 + 5 | 50 | 1 | 50.0000000000000000 +(5 rows) + +INSERT INTO mv_base_a VALUES + (1,0), + (1,0), + (2,30), + (2,30); +SELECT * FROM mv_ivm_avg_bug ORDER BY 1,2,3; + i | sum | count | avg +---+-----+-------+--------------------- + 1 | 10 | 3 | 3.3333333333333333 + 2 | 80 | 3 | 26.6666666666666667 + 3 | 30 | 1 | 30.0000000000000000 + 4 | 40 | 1 | 40.0000000000000000 + 5 | 50 | 1 | 50.0000000000000000 +(5 rows) + +DELETE FROM mv_base_a WHERE (i,j) = (1,0); +DELETE FROM mv_base_a WHERE (i,j) = (2,30); +SELECT * FROM mv_ivm_avg_bug ORDER BY 1,2,3; + i | sum | count | avg +---+-----+-------+--------------------- + 1 | 10 | 1 | 10.0000000000000000 + 2 | 20 | 1 | 20.0000000000000000 + 3 | 30 | 1 | 30.0000000000000000 + 4 | 40 | 1 | 40.0000000000000000 + 5 | 50 | 1 | 50.0000000000000000 +(5 rows) + +ROLLBACK; +-- support MIN(), MAX() aggregate functions +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_min_max AS SELECT i, MIN(j), MAX(j) FROM mv_base_a GROUP BY i; +NOTICE: created index "mv_ivm_min_max_index" on materialized view "mv_ivm_min_max" +SELECT * FROM mv_ivm_min_max ORDER BY 1,2,3; + i | min | max +---+-----+----- + 1 | 10 | 10 + 2 | 20 | 20 + 3 | 30 | 30 + 4 | 40 | 40 + 5 | 50 | 50 +(5 rows) + +INSERT INTO mv_base_a VALUES + (1,11), (1,12), + (2,21), (2,22), + (3,31), (3,32), + (4,41), (4,42), + (5,51), (5,52); +SELECT * FROM mv_ivm_min_max ORDER BY 1,2,3; + i | min | max +---+-----+----- + 1 | 10 | 12 + 2 | 20 | 22 + 3 | 30 | 32 + 4 | 40 | 42 + 5 | 50 | 52 +(5 rows) + +DELETE FROM mv_base_a WHERE (i,j) IN ((1,10), (2,21), (3,32)); +SELECT * FROM mv_ivm_min_max ORDER BY 1,2,3; + i | min | max +---+-----+----- + 1 | 11 | 12 + 2 | 20 | 22 + 3 | 30 | 31 + 4 | 40 | 42 + 5 | 50 | 52 +(5 rows) + +ROLLBACK; +-- support MIN(), MAX() aggregate functions without GROUP clause +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_min_max AS SELECT MIN(j), MAX(j) FROM mv_base_a; +NOTICE: could not create an index on materialized view "mv_ivm_min_max" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +SELECT * FROM mv_ivm_min_max; + min | max +-----+----- + 10 | 50 +(1 row) + +INSERT INTO mv_base_a VALUES + (0,0), (6,60), (7,70); +SELECT * FROM mv_ivm_min_max; + min | max +-----+----- + 0 | 70 +(1 row) + +DELETE FROM mv_base_a WHERE (i,j) IN ((0,0), (7,70)); +SELECT * FROM mv_ivm_min_max; + min | max +-----+----- + 10 | 60 +(1 row) + +DELETE FROM mv_base_a; +SELECT * FROM mv_ivm_min_max; + min | max +-----+----- + | +(1 row) + +ROLLBACK; +-- Test MIN/MAX after search_path change +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_min AS SELECT MIN(j) FROM mv_base_a; +NOTICE: could not create an index on materialized view "mv_ivm_min" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +SELECT * FROM mv_ivm_min; + min +----- + 10 +(1 row) + +CREATE SCHEMA myschema; +GRANT ALL ON SCHEMA myschema TO public; +CREATE TABLE myschema.mv_base_a (j int); +INSERT INTO myschema.mv_base_a VALUES (1); +DELETE FROM mv_base_a WHERE (i,j) = (1,10); +SELECT * FROM mv_ivm_min; + min +----- + 20 +(1 row) + +SET search_path TO myschema,public,pg_catalog; +DELETE FROM public.mv_base_a WHERE (i,j) = (2,20); +SELECT * FROM mv_ivm_min; + min +----- + 30 +(1 row) + +ROLLBACK; +-- aggregate views with column names specified +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg(a) AS SELECT i, SUM(j) FROM mv_base_a GROUP BY i; +NOTICE: created index "mv_ivm_agg_index" on materialized view "mv_ivm_agg" +INSERT INTO mv_base_a VALUES (1,100), (2,200), (3,300); +UPDATE mv_base_a SET j = 2000 WHERE (i,j) = (2,20); +DELETE FROM mv_base_a WHERE (i,j) = (3,30); +SELECT * FROM mv_ivm_agg ORDER BY 1,2; + a | sum +---+------ + 1 | 110 + 2 | 2200 + 3 | 300 + 4 | 40 + 5 | 50 +(5 rows) + +ROLLBACK; +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg(a,b) AS SELECT i, SUM(j) FROM mv_base_a GROUP BY i; +NOTICE: created index "mv_ivm_agg_index" on materialized view "mv_ivm_agg" +INSERT INTO mv_base_a VALUES (1,100), (2,200), (3,300); +UPDATE mv_base_a SET j = 2000 WHERE (i,j) = (2,20); +DELETE FROM mv_base_a WHERE (i,j) = (3,30); +SELECT * FROM mv_ivm_agg ORDER BY 1,2; + a | b +---+------ + 1 | 110 + 2 | 2200 + 3 | 300 + 4 | 40 + 5 | 50 +(5 rows) + +ROLLBACK; +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg(a,b,c) AS SELECT i, SUM(j) FROM mv_base_a GROUP BY i; +ERROR: too many column names were specified +ROLLBACK; +-- support self join view and multiple change on the same table +BEGIN; +CREATE TABLE base_t (i int, v int); +INSERT INTO base_t VALUES (1, 10), (2, 20), (3, 30); +CREATE INCREMENTAL MATERIALIZED VIEW mv_self(v1, v2) AS + SELECT t1.v, t2.v FROM base_t AS t1 JOIN base_t AS t2 ON t1.i = t2.i; +NOTICE: could not create an index on materialized view "mv_self" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +SELECT * FROM mv_self ORDER BY v1; + v1 | v2 +----+---- + 10 | 10 + 20 | 20 + 30 | 30 +(3 rows) + +INSERT INTO base_t VALUES (4,40); +DELETE FROM base_t WHERE i = 1; +UPDATE base_t SET v = v*10 WHERE i=2; +SELECT * FROM mv_self ORDER BY v1; + v1 | v2 +-----+----- + 30 | 30 + 40 | 40 + 200 | 200 +(3 rows) + +WITH + ins_t1 AS (INSERT INTO base_t VALUES (5,50) RETURNING 1), + ins_t2 AS (INSERT INTO base_t VALUES (6,60) RETURNING 1), + upd_t AS (UPDATE base_t SET v = v + 100 RETURNING 1), + dlt_t AS (DELETE FROM base_t WHERE i IN (4,5) RETURNING 1) +SELECT NULL; + ?column? +---------- + +(1 row) + +SELECT * FROM mv_self ORDER BY v1; + v1 | v2 +-----+----- + 50 | 50 + 60 | 60 + 130 | 130 + 300 | 300 +(4 rows) + +--- with sub-transactions +SAVEPOINT p1; +INSERT INTO base_t VALUES (7,70); +RELEASE SAVEPOINT p1; +INSERT INTO base_t VALUES (7,77); +SELECT * FROM mv_self ORDER BY v1, v2; + v1 | v2 +-----+----- + 50 | 50 + 60 | 60 + 70 | 70 + 70 | 77 + 77 | 70 + 77 | 77 + 130 | 130 + 300 | 300 +(8 rows) + +ROLLBACK; +-- support simultaneous table changes +BEGIN; +CREATE TABLE base_r (i int, v int); +CREATE TABLE base_s (i int, v int); +INSERT INTO base_r VALUES (1, 10), (2, 20), (3, 30); +INSERT INTO base_s VALUES (1, 100), (2, 200), (3, 300); +CREATE INCREMENTAL MATERIALIZED VIEW mv(v1, v2) AS + SELECT r.v, s.v FROM base_r AS r JOIN base_s AS s USING(i); +NOTICE: could not create an index on materialized view "mv" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +SELECT * FROM mv ORDER BY v1; + v1 | v2 +----+----- + 10 | 100 + 20 | 200 + 30 | 300 +(3 rows) + +WITH + ins_r AS (INSERT INTO base_r VALUES (1,11) RETURNING 1), + ins_r2 AS (INSERT INTO base_r VALUES (3,33) RETURNING 1), + ins_s AS (INSERT INTO base_s VALUES (2,222) RETURNING 1), + upd_r AS (UPDATE base_r SET v = v + 1000 WHERE i = 2 RETURNING 1), + dlt_s AS (DELETE FROM base_s WHERE i = 3 RETURNING 1) +SELECT NULL; + ?column? +---------- + +(1 row) + +SELECT * FROM mv ORDER BY v1; + v1 | v2 +------+----- + 10 | 100 + 11 | 100 + 1020 | 200 + 1020 | 222 +(4 rows) + +ROLLBACK; +-- support foreign reference constraints +BEGIN; +CREATE TABLE ri1 (i int PRIMARY KEY); +CREATE TABLE ri2 (i int PRIMARY KEY REFERENCES ri1(i) ON UPDATE CASCADE ON DELETE CASCADE, v int); +INSERT INTO ri1 VALUES (1),(2),(3); +INSERT INTO ri2 VALUES (1),(2),(3); +CREATE INCREMENTAL MATERIALIZED VIEW mv_ri(i1, i2) AS + SELECT ri1.i, ri2.i FROM ri1 JOIN ri2 USING(i); +NOTICE: created index "mv_ri_index" on materialized view "mv_ri" +SELECT * FROM mv_ri ORDER BY i1; + i1 | i2 +----+---- + 1 | 1 + 2 | 2 + 3 | 3 +(3 rows) + +UPDATE ri1 SET i=10 where i=1; +DELETE FROM ri1 WHERE i=2; +SELECT * FROM mv_ri ORDER BY i2; + i1 | i2 +----+---- + 3 | 3 + 10 | 10 +(2 rows) + +ROLLBACK; +-- views including NULL +BEGIN; +CREATE TABLE base_t (i int, v int); +INSERT INTO base_t VALUES (1,10),(2, NULL); +CREATE INCREMENTAL MATERIALIZED VIEW mv AS SELECT * FROM base_t; +NOTICE: could not create an index on materialized view "mv" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +SELECT * FROM mv ORDER BY i; + i | v +---+---- + 1 | 10 + 2 | +(2 rows) + +UPDATE base_t SET v = 20 WHERE i = 2; +SELECT * FROM mv ORDER BY i; + i | v +---+---- + 1 | 10 + 2 | 20 +(2 rows) + +ROLLBACK; +BEGIN; +CREATE TABLE base_t (i int); +CREATE INCREMENTAL MATERIALIZED VIEW mv AS SELECT * FROM base_t; +NOTICE: could not create an index on materialized view "mv" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +SELECT * FROM mv ORDER BY i; + i +--- +(0 rows) + +INSERT INTO base_t VALUES (1),(NULL); +SELECT * FROM mv ORDER BY i; + i +--- + 1 + +(2 rows) + +ROLLBACK; +BEGIN; +CREATE TABLE base_t (i int, v int); +INSERT INTO base_t VALUES (NULL, 1), (NULL, 2), (1, 10), (1, 20); +CREATE INCREMENTAL MATERIALIZED VIEW mv AS SELECT i, sum(v) FROM base_t GROUP BY i; +NOTICE: created index "mv_index" on materialized view "mv" +SELECT * FROM mv ORDER BY i; + i | sum +---+----- + 1 | 30 + | 3 +(2 rows) + +UPDATE base_t SET v = v * 10; +SELECT * FROM mv ORDER BY i; + i | sum +---+----- + 1 | 300 + | 30 +(2 rows) + +ROLLBACK; +BEGIN; +CREATE TABLE base_t (i int, v int); +INSERT INTO base_t VALUES (NULL, 1), (NULL, 2), (NULL, 3), (NULL, 4), (NULL, 5); +CREATE INCREMENTAL MATERIALIZED VIEW mv AS SELECT i, min(v), max(v) FROM base_t GROUP BY i; +NOTICE: created index "mv_index" on materialized view "mv" +SELECT * FROM mv ORDER BY i; + i | min | max +---+-----+----- + | 1 | 5 +(1 row) + +DELETE FROM base_t WHERE v = 1; +SELECT * FROM mv ORDER BY i; + i | min | max +---+-----+----- + | 2 | 5 +(1 row) + +DELETE FROM base_t WHERE v = 3; +SELECT * FROM mv ORDER BY i; + i | min | max +---+-----+----- + | 2 | 5 +(1 row) + +DELETE FROM base_t WHERE v = 5; +SELECT * FROM mv ORDER BY i; + i | min | max +---+-----+----- + | 2 | 4 +(1 row) + +ROLLBACK; +-- IMMV containing user defined type +BEGIN; +CREATE TYPE mytype; +CREATE FUNCTION mytype_in(cstring) + RETURNS mytype AS 'int4in' + LANGUAGE INTERNAL STRICT IMMUTABLE; +NOTICE: return type mytype is only a shell +CREATE FUNCTION mytype_out(mytype) + RETURNS cstring AS 'int4out' + LANGUAGE INTERNAL STRICT IMMUTABLE; +NOTICE: argument type mytype is only a shell +CREATE TYPE mytype ( + LIKE = int4, + INPUT = mytype_in, + OUTPUT = mytype_out +); +CREATE FUNCTION mytype_eq(mytype, mytype) + RETURNS bool AS 'int4eq' + LANGUAGE INTERNAL STRICT IMMUTABLE; +CREATE FUNCTION mytype_lt(mytype, mytype) + RETURNS bool AS 'int4lt' + LANGUAGE INTERNAL STRICT IMMUTABLE; +CREATE FUNCTION mytype_cmp(mytype, mytype) + RETURNS integer AS 'btint4cmp' + LANGUAGE INTERNAL STRICT IMMUTABLE; +CREATE OPERATOR = ( + leftarg = mytype, rightarg = mytype, + procedure = mytype_eq); +CREATE OPERATOR < ( + leftarg = mytype, rightarg = mytype, + procedure = mytype_lt); +CREATE OPERATOR CLASS mytype_ops + DEFAULT FOR TYPE mytype USING btree AS + OPERATOR 1 <, + OPERATOR 3 = , + FUNCTION 1 mytype_cmp(mytype,mytype); +CREATE TABLE t_mytype (x mytype); +CREATE INCREMENTAL MATERIALIZED VIEW mv_mytype AS + SELECT * FROM t_mytype; +NOTICE: could not create an index on materialized view "mv_mytype" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +INSERT INTO t_mytype VALUES ('1'::mytype); +SELECT * FROM mv_mytype; + x +--- + 1 +(1 row) + +ROLLBACK; +-- outer join is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv(a,b) AS SELECT a.i, b.i FROM mv_base_a a LEFT JOIN mv_base_b b ON a.i=b.i; +ERROR: OUTER JOIN is not supported on incrementally maintainable materialized view +-- CTE is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv AS + WITH b AS ( SELECT * FROM mv_base_b) SELECT a.i,a.j FROM mv_base_a a, b WHERE a.i = b.i; +ERROR: CTE is not supported on incrementally maintainable materialized view +-- contain system column +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm01 AS SELECT i,j,xmin FROM mv_base_a; +ERROR: system column is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm02 AS SELECT i,j FROM mv_base_a WHERE xmin = '610'; +ERROR: system column is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm04 AS SELECT i,j,xmin::text AS x_min FROM mv_base_a; +ERROR: system column is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm06 AS SELECT i,j,xidsend(xmin) AS x_min FROM mv_base_a; +ERROR: system column is not supported on incrementally maintainable materialized view +-- contain subquery +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm03 AS SELECT i,j FROM mv_base_a WHERE i IN (SELECT i FROM mv_base_b WHERE k < 103 ); +ERROR: subquery is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm04 AS SELECT a.i,a.j FROM mv_base_a a, (SELECT * FROM mv_base_b) b WHERE a.i = b.i; +ERROR: subquery is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm05 AS SELECT i,j, (SELECT k FROM mv_base_b b WHERE a.i = b.i) FROM mv_base_a a; +ERROR: subquery is not supported on incrementally maintainable materialized view +-- contain ORDER BY +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm07 AS SELECT i,j,k FROM mv_base_a a INNER JOIN mv_base_b b USING(i) ORDER BY i,j,k; +ERROR: ORDER BY clause is not supported on incrementally maintainable materialized view +-- contain HAVING +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm08 AS SELECT i,j,k FROM mv_base_a a INNER JOIN mv_base_b b USING(i) GROUP BY i,j,k HAVING SUM(i) > 5; +ERROR: HAVING clause is not supported on incrementally maintainable materialized view +-- contain view or materialized view +CREATE VIEW b_view AS SELECT i,k FROM mv_base_b; +CREATE MATERIALIZED VIEW b_mview AS SELECT i,k FROM mv_base_b; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm07 AS SELECT a.i,a.j FROM mv_base_a a,b_view b WHERE a.i = b.i; +ERROR: VIEW or MATERIALIZED VIEW is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm08 AS SELECT a.i,a.j FROM mv_base_a a,b_mview b WHERE a.i = b.i; +ERROR: VIEW or MATERIALIZED VIEW is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm09 AS SELECT a.i,a.j FROM mv_base_a a, (SELECT i, COUNT(*) FROM mv_base_b GROUP BY i) b WHERE a.i = b.i; +ERROR: subquery is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm10 AS SELECT a.i,a.j FROM mv_base_a a WHERE EXISTS(SELECT 1 FROM mv_base_b b WHERE a.i = b.i) OR a.i > 5; +ERROR: subquery is not supported on incrementally maintainable materialized view +-- contain mutable functions +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm12 AS SELECT i,j FROM mv_base_a WHERE i = random()::int; +ERROR: mutable function is not supported on incrementally maintainable materialized view +HINT: functions must be marked IMMUTABLE +-- LIMIT/OFFSET is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm13 AS SELECT i,j FROM mv_base_a LIMIT 10 OFFSET 5; +ERROR: LIMIT/OFFSET clause is not supported on incrementally maintainable materialized view +-- DISTINCT ON is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm14 AS SELECT DISTINCT ON(i) i, j FROM mv_base_a; +ERROR: DISTINCT ON is not supported on incrementally maintainable materialized view +-- TABLESAMPLE clause is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm15 AS SELECT i, j FROM mv_base_a TABLESAMPLE SYSTEM(50); +ERROR: TABLESAMPLE clause is not supported on incrementally maintainable materialized view +-- window functions are not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm16 AS SELECT *, cume_dist() OVER (ORDER BY i) AS rank FROM mv_base_a; +ERROR: window functions are not supported on incrementally maintainable materialized view +-- aggregate function with some options is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm17 AS SELECT COUNT(*) FILTER(WHERE i < 3) FROM mv_base_a; +ERROR: aggregate function with FILTER clause is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm18 AS SELECT COUNT(DISTINCT i) FROM mv_base_a; +ERROR: aggregate function with DISTINCT arguments is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm19 AS SELECT array_agg(j ORDER BY i DESC) FROM mv_base_a; +ERROR: aggregate function with ORDER clause is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm20 AS SELECT i,SUM(j) FROM mv_base_a GROUP BY GROUPING SETS((i),()); +ERROR: GROUPING SETS, ROLLUP, or CUBE clauses is not supported on incrementally maintainable materialized view +-- inheritance parent is not supported +BEGIN; +CREATE TABLE parent (i int, v int); +CREATE TABLE child_a(options text) INHERITS(parent); +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm21 AS SELECT * FROM parent; +ERROR: inheritance parent is not supported on incrementally maintainable materialized view +ROLLBACK; +-- UNION statement is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm22 AS SELECT i,j FROM mv_base_a UNION ALL SELECT i,k FROM mv_base_b;; +ERROR: UNION/INTERSECT/EXCEPT statements are not supported on incrementally maintainable materialized view +-- empty target list is not allowed with IVM +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm25 AS SELECT FROM mv_base_a; +ERROR: empty target list is not supported on incrementally maintainable materialized view +-- FOR UPDATE/SHARE is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm26 AS SELECT i,j FROM mv_base_a FOR UPDATE; +ERROR: FOR UPDATE/SHARE clause is not supported on incrementally maintainable materialized view +-- tartget list cannot contain ivm column that start with '__ivm' +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm28 AS SELECT i AS "__ivm_count__" FROM mv_base_a; +ERROR: column name __ivm_count__ is not supported on incrementally maintainable materialized view +-- expressions specified in GROUP BY must appear in the target list. +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm29 AS SELECT COUNT(i) FROM mv_base_a GROUP BY i; +ERROR: GROUP BY expression not appearing in select list is not supported on incrementally maintainable materialized view +-- experssions containing an aggregate is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm30 AS SELECT sum(i)*0.5 FROM mv_base_a; +ERROR: expression containing an aggregate in it is not supported on incrementally maintainable materialized view +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm31 AS SELECT sum(i)/sum(j) FROM mv_base_a; +ERROR: expression containing an aggregate in it is not supported on incrementally maintainable materialized view +-- VALUES is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_only_values1 AS values(1); +ERROR: VALUES is not supported on incrementally maintainable materialized view +-- views containing base tables with Row Level Security +DROP USER IF EXISTS ivm_admin; +NOTICE: role "ivm_admin" does not exist, skipping +DROP USER IF EXISTS ivm_user; +NOTICE: role "ivm_user" does not exist, skipping +CREATE USER ivm_admin; +CREATE USER ivm_user; +--- create a table with RLS +SET SESSION AUTHORIZATION ivm_admin; +CREATE TABLE rls_tbl(id int, data text, owner name); +INSERT INTO rls_tbl VALUES + (1,'foo','ivm_user'), + (2,'bar','postgres'); +CREATE TABLE num_tbl(id int, num text); +INSERT INTO num_tbl VALUES + (1,'one'), + (2,'two'), + (3,'three'), + (4,'four'), + (5,'five'), + (6,'six'); +--- Users can access only their own rows +CREATE POLICY rls_tbl_policy ON rls_tbl FOR SELECT TO PUBLIC USING(owner = current_user); +ALTER TABLE rls_tbl ENABLE ROW LEVEL SECURITY; +GRANT ALL on rls_tbl TO PUBLIC; +GRANT ALL on num_tbl TO PUBLIC; +--- create a view owned by ivm_user +SET SESSION AUTHORIZATION ivm_user; +CREATE INCREMENTAL MATERIALIZED VIEW ivm_rls AS SELECT * FROM rls_tbl; +NOTICE: could not create an index on materialized view "ivm_rls" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +SELECT id, data, owner FROM ivm_rls ORDER BY 1,2,3; + id | data | owner +----+------+---------- + 1 | foo | ivm_user +(1 row) + +RESET SESSION AUTHORIZATION; +--- inserts rows owned by different users +INSERT INTO rls_tbl VALUES + (3,'baz','ivm_user'), + (4,'qux','postgres'); +SELECT id, data, owner FROM ivm_rls ORDER BY 1,2,3; + id | data | owner +----+------+---------- + 1 | foo | ivm_user + 3 | baz | ivm_user +(2 rows) + +--- combination of diffent kinds of commands +WITH + i AS (INSERT INTO rls_tbl VALUES(5,'quux','postgres'), (6,'corge','ivm_user')), + u AS (UPDATE rls_tbl SET owner = 'postgres' WHERE id = 1), + u2 AS (UPDATE rls_tbl SET owner = 'ivm_user' WHERE id = 2) +SELECT; +-- +(1 row) + +SELECT id, data, owner FROM ivm_rls ORDER BY 1,2,3; + id | data | owner +----+-------+---------- + 2 | bar | ivm_user + 3 | baz | ivm_user + 6 | corge | ivm_user +(3 rows) + +--- +SET SESSION AUTHORIZATION ivm_user; +CREATE INCREMENTAL MATERIALIZED VIEW ivm_rls2 AS SELECT * FROM rls_tbl JOIN num_tbl USING(id); +NOTICE: could not create an index on materialized view "ivm_rls2" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +RESET SESSION AUTHORIZATION; +WITH + x AS (UPDATE rls_tbl SET data = data || '_2' where id in (3,4)), + y AS (UPDATE num_tbl SET num = num || '_2' where id in (3,4)) +SELECT; +-- +(1 row) + +SELECT * FROM ivm_rls2 ORDER BY 1,2,3; + id | data | owner | num +----+-------+----------+--------- + 2 | bar | ivm_user | two + 3 | baz_2 | ivm_user | three_2 + 6 | corge | ivm_user | six +(3 rows) + +-- automatic index creation +CREATE TABLE base_a (i int primary key, j int); +CREATE TABLE base_b (i int primary key, j int); +--- group by: create an index +CREATE INCREMENTAL MATERIALIZED VIEW mv_idx1 AS SELECT i, sum(j) FROM base_a GROUP BY i; +NOTICE: created index "mv_idx1_index" on materialized view "mv_idx1" +--- distinct: create an index +CREATE INCREMENTAL MATERIALIZED VIEW mv_idx2 AS SELECT DISTINCT j FROM base_a; +NOTICE: created index "mv_idx2_index" on materialized view "mv_idx2" +--- with all pkey columns: create an index +CREATE INCREMENTAL MATERIALIZED VIEW mv_idx3(i_a, i_b) AS SELECT a.i, b.i FROM base_a a, base_b b; +NOTICE: created index "mv_idx3_index" on materialized view "mv_idx3" +--- missing some pkey columns: no index +CREATE INCREMENTAL MATERIALIZED VIEW mv_idx4 AS SELECT j FROM base_a; +NOTICE: could not create an index on materialized view "mv_idx4" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +CREATE INCREMENTAL MATERIALIZED VIEW mv_idx5 AS SELECT a.i, b.j FROM base_a a, base_b b; +NOTICE: could not create an index on materialized view "mv_idx5" automatically +DETAIL: This target list does not have all the primary key columns, or this view does not contain GROUP BY or DISTINCT clause. +HINT: Create an index on the materialized view for efficient incremental maintenance. +-- cleanup +DROP TABLE rls_tbl CASCADE; +NOTICE: drop cascades to 2 other objects +DETAIL: drop cascades to materialized view ivm_rls +drop cascades to materialized view ivm_rls2 +DROP TABLE num_tbl CASCADE; +DROP USER ivm_user; +DROP USER ivm_admin; +DROP TABLE mv_base_b CASCADE; +NOTICE: drop cascades to 3 other objects +DETAIL: drop cascades to materialized view mv_ivm_1 +drop cascades to view b_view +drop cascades to materialized view b_mview +DROP TABLE mv_base_a CASCADE; diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule index 4df9d8503b..21f7247a07 100644 --- a/src/test/regress/parallel_schedule +++ b/src/test/regress/parallel_schedule @@ -78,7 +78,7 @@ test: brin_bloom brin_multi # psql depends on create_am # amutils depends on geometry, create_index_spgist, hash_index, brin # ---------- -test: create_table_like alter_generic alter_operator misc async dbsize merge misc_functions sysviews tsrf tid tidscan tidrangescan collate.icu.utf8 incremental_sort create_role +test: create_table_like alter_generic alter_operator misc async dbsize merge misc_functions sysviews tsrf tid tidscan tidrangescan collate.icu.utf8 incremental_sort create_role incremental_matview # collate.*.utf8 tests cannot be run in parallel with each other test: rules psql psql_crosstab amutils stats_ext collate.linux.utf8 collate.windows.win1252 diff --git a/src/test/regress/sql/incremental_matview.sql b/src/test/regress/sql/incremental_matview.sql new file mode 100644 index 0000000000..82686f9324 --- /dev/null +++ b/src/test/regress/sql/incremental_matview.sql @@ -0,0 +1,533 @@ +-- create a table to use as a basis for views and materialized views in various combinations +CREATE TABLE mv_base_a (i int, j int); +INSERT INTO mv_base_a VALUES + (1,10), + (2,20), + (3,30), + (4,40), + (5,50); +CREATE TABLE mv_base_b (i int, k int); +INSERT INTO mv_base_b VALUES + (1,101), + (2,102), + (3,103), + (4,104); + +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_1 AS SELECT i,j,k FROM mv_base_a a INNER JOIN mv_base_b b USING(i) WITH NO DATA; +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; +REFRESH MATERIALIZED VIEW mv_ivm_1; +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; + +-- REFRESH WITH NO DATA +BEGIN; +CREATE FUNCTION dummy_ivm_trigger_func() RETURNS TRIGGER AS $$ + BEGIN + RETURN NULL; + END +$$ language plpgsql; + +CREATE CONSTRAINT TRIGGER dummy_ivm_trigger AFTER INSERT +ON mv_base_a FROM mv_ivm_1 FOR EACH ROW +EXECUTE PROCEDURE dummy_ivm_trigger_func(); + +SELECT COUNT(*) +FROM pg_depend pd INNER JOIN pg_trigger pt ON pd.objid = pt.oid +WHERE pd.classid = 'pg_trigger'::regclass AND pd.refobjid = 'mv_ivm_1'::regclass; + +REFRESH MATERIALIZED VIEW mv_ivm_1 WITH NO DATA; + +SELECT COUNT(*) +FROM pg_depend pd INNER JOIN pg_trigger pt ON pd.objid = pt.oid +WHERE pd.classid = 'pg_trigger'::regclass AND pd.refobjid = 'mv_ivm_1'::regclass; +ROLLBACK; + +-- immediate maintenance +BEGIN; +INSERT INTO mv_base_b VALUES(5,105); +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; +UPDATE mv_base_a SET j = 0 WHERE i = 1; +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; +DELETE FROM mv_base_b WHERE (i,k) = (5,105); +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; +ROLLBACK; +SELECT * FROM mv_ivm_1 ORDER BY 1,2,3; + +-- rename of IVM columns +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_rename AS SELECT DISTINCT * FROM mv_base_a; +ALTER MATERIALIZED VIEW mv_ivm_rename RENAME COLUMN __ivm_count__ TO xxx; +DROP MATERIALIZED VIEW mv_ivm_rename; + +-- unique index on IVM columns +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_unique AS SELECT DISTINCT * FROM mv_base_a; +CREATE UNIQUE INDEX ON mv_ivm_unique(__ivm_count__); +CREATE UNIQUE INDEX ON mv_ivm_unique((__ivm_count__)); +CREATE UNIQUE INDEX ON mv_ivm_unique((__ivm_count__ + 1)); +DROP MATERIALIZED VIEW mv_ivm_unique; + +-- TRUNCATE a base table in join views +BEGIN; +TRUNCATE mv_base_a; +SELECT * FROM mv_ivm_1; +ROLLBACK; + +BEGIN; +TRUNCATE mv_base_b; +SELECT * FROM mv_ivm_1; +ROLLBACK; + +-- some query syntax +BEGIN; +CREATE FUNCTION ivm_func() RETURNS int LANGUAGE 'sql' + AS 'SELECT 1' IMMUTABLE; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_func AS SELECT * FROM ivm_func(); +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_no_tbl AS SELECT 1; +ROLLBACK; + +-- result of materialized view have DISTINCT clause or the duplicate result. +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_duplicate AS SELECT j FROM mv_base_a; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_distinct AS SELECT DISTINCT j FROM mv_base_a; +INSERT INTO mv_base_a VALUES(6,20); +SELECT * FROM mv_ivm_duplicate ORDER BY 1; +SELECT * FROM mv_ivm_distinct ORDER BY 1; +DELETE FROM mv_base_a WHERE (i,j) = (2,20); +SELECT * FROM mv_ivm_duplicate ORDER BY 1; +SELECT * FROM mv_ivm_distinct ORDER BY 1; +ROLLBACK; + +-- support SUM(), COUNT() and AVG() aggregate functions +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg AS SELECT i, SUM(j), COUNT(i), AVG(j) FROM mv_base_a GROUP BY i; +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3,4; +INSERT INTO mv_base_a VALUES(2,100); +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3,4; +UPDATE mv_base_a SET j = 200 WHERE (i,j) = (2,100); +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3,4; +DELETE FROM mv_base_a WHERE (i,j) = (2,200); +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3,4; +ROLLBACK; + +-- support COUNT(*) aggregate function +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg AS SELECT i, SUM(j), COUNT(*) FROM mv_base_a GROUP BY i; +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3; +INSERT INTO mv_base_a VALUES(2,100); +SELECT * FROM mv_ivm_agg ORDER BY 1,2,3; +ROLLBACK; + +-- TRUNCATE a base table in aggregate views +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg AS SELECT i, SUM(j), COUNT(*) FROM mv_base_a GROUP BY i; +TRUNCATE mv_base_a; +SELECT sum, count FROM mv_ivm_agg; +SELECT i, SUM(j), COUNT(*) FROM mv_base_a GROUP BY i; +ROLLBACK; + +-- support aggregate functions without GROUP clause +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_group AS SELECT SUM(j), COUNT(j), AVG(j) FROM mv_base_a; +SELECT * FROM mv_ivm_group ORDER BY 1; +INSERT INTO mv_base_a VALUES(6,60); +SELECT * FROM mv_ivm_group ORDER BY 1; +DELETE FROM mv_base_a; +SELECT * FROM mv_ivm_group ORDER BY 1; +ROLLBACK; + +-- TRUNCATE a base table in aggregate views without GROUP clause +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_group AS SELECT SUM(j), COUNT(j), AVG(j) FROM mv_base_a; +TRUNCATE mv_base_a; +SELECT sum, count, avg FROM mv_ivm_group; +SELECT SUM(j), COUNT(j), AVG(j) FROM mv_base_a; +ROLLBACK; + +-- resolved issue: When use AVG() function and values is indivisible, result of AVG() is incorrect. +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_avg_bug AS SELECT i, SUM(j), COUNT(j), AVG(j) FROM mv_base_A GROUP BY i; +SELECT * FROM mv_ivm_avg_bug ORDER BY 1,2,3; +INSERT INTO mv_base_a VALUES + (1,0), + (1,0), + (2,30), + (2,30); +SELECT * FROM mv_ivm_avg_bug ORDER BY 1,2,3; +DELETE FROM mv_base_a WHERE (i,j) = (1,0); +DELETE FROM mv_base_a WHERE (i,j) = (2,30); +SELECT * FROM mv_ivm_avg_bug ORDER BY 1,2,3; +ROLLBACK; + +-- support MIN(), MAX() aggregate functions +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_min_max AS SELECT i, MIN(j), MAX(j) FROM mv_base_a GROUP BY i; +SELECT * FROM mv_ivm_min_max ORDER BY 1,2,3; +INSERT INTO mv_base_a VALUES + (1,11), (1,12), + (2,21), (2,22), + (3,31), (3,32), + (4,41), (4,42), + (5,51), (5,52); +SELECT * FROM mv_ivm_min_max ORDER BY 1,2,3; +DELETE FROM mv_base_a WHERE (i,j) IN ((1,10), (2,21), (3,32)); +SELECT * FROM mv_ivm_min_max ORDER BY 1,2,3; +ROLLBACK; + +-- support MIN(), MAX() aggregate functions without GROUP clause +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_min_max AS SELECT MIN(j), MAX(j) FROM mv_base_a; +SELECT * FROM mv_ivm_min_max; +INSERT INTO mv_base_a VALUES + (0,0), (6,60), (7,70); +SELECT * FROM mv_ivm_min_max; +DELETE FROM mv_base_a WHERE (i,j) IN ((0,0), (7,70)); +SELECT * FROM mv_ivm_min_max; +DELETE FROM mv_base_a; +SELECT * FROM mv_ivm_min_max; +ROLLBACK; + +-- Test MIN/MAX after search_path change +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_min AS SELECT MIN(j) FROM mv_base_a; +SELECT * FROM mv_ivm_min; + +CREATE SCHEMA myschema; +GRANT ALL ON SCHEMA myschema TO public; +CREATE TABLE myschema.mv_base_a (j int); +INSERT INTO myschema.mv_base_a VALUES (1); + +DELETE FROM mv_base_a WHERE (i,j) = (1,10); +SELECT * FROM mv_ivm_min; + +SET search_path TO myschema,public,pg_catalog; +DELETE FROM public.mv_base_a WHERE (i,j) = (2,20); +SELECT * FROM mv_ivm_min; +ROLLBACK; + +-- aggregate views with column names specified +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg(a) AS SELECT i, SUM(j) FROM mv_base_a GROUP BY i; +INSERT INTO mv_base_a VALUES (1,100), (2,200), (3,300); +UPDATE mv_base_a SET j = 2000 WHERE (i,j) = (2,20); +DELETE FROM mv_base_a WHERE (i,j) = (3,30); +SELECT * FROM mv_ivm_agg ORDER BY 1,2; +ROLLBACK; +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg(a,b) AS SELECT i, SUM(j) FROM mv_base_a GROUP BY i; +INSERT INTO mv_base_a VALUES (1,100), (2,200), (3,300); +UPDATE mv_base_a SET j = 2000 WHERE (i,j) = (2,20); +DELETE FROM mv_base_a WHERE (i,j) = (3,30); +SELECT * FROM mv_ivm_agg ORDER BY 1,2; +ROLLBACK; +BEGIN; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_agg(a,b,c) AS SELECT i, SUM(j) FROM mv_base_a GROUP BY i; +ROLLBACK; + +-- support self join view and multiple change on the same table +BEGIN; +CREATE TABLE base_t (i int, v int); +INSERT INTO base_t VALUES (1, 10), (2, 20), (3, 30); +CREATE INCREMENTAL MATERIALIZED VIEW mv_self(v1, v2) AS + SELECT t1.v, t2.v FROM base_t AS t1 JOIN base_t AS t2 ON t1.i = t2.i; +SELECT * FROM mv_self ORDER BY v1; +INSERT INTO base_t VALUES (4,40); +DELETE FROM base_t WHERE i = 1; +UPDATE base_t SET v = v*10 WHERE i=2; +SELECT * FROM mv_self ORDER BY v1; +WITH + ins_t1 AS (INSERT INTO base_t VALUES (5,50) RETURNING 1), + ins_t2 AS (INSERT INTO base_t VALUES (6,60) RETURNING 1), + upd_t AS (UPDATE base_t SET v = v + 100 RETURNING 1), + dlt_t AS (DELETE FROM base_t WHERE i IN (4,5) RETURNING 1) +SELECT NULL; +SELECT * FROM mv_self ORDER BY v1; + +--- with sub-transactions +SAVEPOINT p1; +INSERT INTO base_t VALUES (7,70); +RELEASE SAVEPOINT p1; +INSERT INTO base_t VALUES (7,77); +SELECT * FROM mv_self ORDER BY v1, v2; + +ROLLBACK; + +-- support simultaneous table changes +BEGIN; +CREATE TABLE base_r (i int, v int); +CREATE TABLE base_s (i int, v int); +INSERT INTO base_r VALUES (1, 10), (2, 20), (3, 30); +INSERT INTO base_s VALUES (1, 100), (2, 200), (3, 300); +CREATE INCREMENTAL MATERIALIZED VIEW mv(v1, v2) AS + SELECT r.v, s.v FROM base_r AS r JOIN base_s AS s USING(i); +SELECT * FROM mv ORDER BY v1; +WITH + ins_r AS (INSERT INTO base_r VALUES (1,11) RETURNING 1), + ins_r2 AS (INSERT INTO base_r VALUES (3,33) RETURNING 1), + ins_s AS (INSERT INTO base_s VALUES (2,222) RETURNING 1), + upd_r AS (UPDATE base_r SET v = v + 1000 WHERE i = 2 RETURNING 1), + dlt_s AS (DELETE FROM base_s WHERE i = 3 RETURNING 1) +SELECT NULL; +SELECT * FROM mv ORDER BY v1; +ROLLBACK; + +-- support foreign reference constraints +BEGIN; +CREATE TABLE ri1 (i int PRIMARY KEY); +CREATE TABLE ri2 (i int PRIMARY KEY REFERENCES ri1(i) ON UPDATE CASCADE ON DELETE CASCADE, v int); +INSERT INTO ri1 VALUES (1),(2),(3); +INSERT INTO ri2 VALUES (1),(2),(3); +CREATE INCREMENTAL MATERIALIZED VIEW mv_ri(i1, i2) AS + SELECT ri1.i, ri2.i FROM ri1 JOIN ri2 USING(i); +SELECT * FROM mv_ri ORDER BY i1; +UPDATE ri1 SET i=10 where i=1; +DELETE FROM ri1 WHERE i=2; +SELECT * FROM mv_ri ORDER BY i2; +ROLLBACK; + +-- views including NULL +BEGIN; +CREATE TABLE base_t (i int, v int); +INSERT INTO base_t VALUES (1,10),(2, NULL); +CREATE INCREMENTAL MATERIALIZED VIEW mv AS SELECT * FROM base_t; +SELECT * FROM mv ORDER BY i; +UPDATE base_t SET v = 20 WHERE i = 2; +SELECT * FROM mv ORDER BY i; +ROLLBACK; + +BEGIN; +CREATE TABLE base_t (i int); +CREATE INCREMENTAL MATERIALIZED VIEW mv AS SELECT * FROM base_t; +SELECT * FROM mv ORDER BY i; +INSERT INTO base_t VALUES (1),(NULL); +SELECT * FROM mv ORDER BY i; +ROLLBACK; + +BEGIN; +CREATE TABLE base_t (i int, v int); +INSERT INTO base_t VALUES (NULL, 1), (NULL, 2), (1, 10), (1, 20); +CREATE INCREMENTAL MATERIALIZED VIEW mv AS SELECT i, sum(v) FROM base_t GROUP BY i; +SELECT * FROM mv ORDER BY i; +UPDATE base_t SET v = v * 10; +SELECT * FROM mv ORDER BY i; +ROLLBACK; + +BEGIN; +CREATE TABLE base_t (i int, v int); +INSERT INTO base_t VALUES (NULL, 1), (NULL, 2), (NULL, 3), (NULL, 4), (NULL, 5); +CREATE INCREMENTAL MATERIALIZED VIEW mv AS SELECT i, min(v), max(v) FROM base_t GROUP BY i; +SELECT * FROM mv ORDER BY i; +DELETE FROM base_t WHERE v = 1; +SELECT * FROM mv ORDER BY i; +DELETE FROM base_t WHERE v = 3; +SELECT * FROM mv ORDER BY i; +DELETE FROM base_t WHERE v = 5; +SELECT * FROM mv ORDER BY i; +ROLLBACK; + +-- IMMV containing user defined type +BEGIN; + +CREATE TYPE mytype; +CREATE FUNCTION mytype_in(cstring) + RETURNS mytype AS 'int4in' + LANGUAGE INTERNAL STRICT IMMUTABLE; +CREATE FUNCTION mytype_out(mytype) + RETURNS cstring AS 'int4out' + LANGUAGE INTERNAL STRICT IMMUTABLE; +CREATE TYPE mytype ( + LIKE = int4, + INPUT = mytype_in, + OUTPUT = mytype_out +); + +CREATE FUNCTION mytype_eq(mytype, mytype) + RETURNS bool AS 'int4eq' + LANGUAGE INTERNAL STRICT IMMUTABLE; +CREATE FUNCTION mytype_lt(mytype, mytype) + RETURNS bool AS 'int4lt' + LANGUAGE INTERNAL STRICT IMMUTABLE; +CREATE FUNCTION mytype_cmp(mytype, mytype) + RETURNS integer AS 'btint4cmp' + LANGUAGE INTERNAL STRICT IMMUTABLE; + +CREATE OPERATOR = ( + leftarg = mytype, rightarg = mytype, + procedure = mytype_eq); +CREATE OPERATOR < ( + leftarg = mytype, rightarg = mytype, + procedure = mytype_lt); + +CREATE OPERATOR CLASS mytype_ops + DEFAULT FOR TYPE mytype USING btree AS + OPERATOR 1 <, + OPERATOR 3 = , + FUNCTION 1 mytype_cmp(mytype,mytype); + +CREATE TABLE t_mytype (x mytype); +CREATE INCREMENTAL MATERIALIZED VIEW mv_mytype AS + SELECT * FROM t_mytype; +INSERT INTO t_mytype VALUES ('1'::mytype); +SELECT * FROM mv_mytype; + +ROLLBACK; + +-- outer join is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv(a,b) AS SELECT a.i, b.i FROM mv_base_a a LEFT JOIN mv_base_b b ON a.i=b.i; +-- CTE is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv AS + WITH b AS ( SELECT * FROM mv_base_b) SELECT a.i,a.j FROM mv_base_a a, b WHERE a.i = b.i; +-- contain system column +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm01 AS SELECT i,j,xmin FROM mv_base_a; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm02 AS SELECT i,j FROM mv_base_a WHERE xmin = '610'; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm04 AS SELECT i,j,xmin::text AS x_min FROM mv_base_a; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm06 AS SELECT i,j,xidsend(xmin) AS x_min FROM mv_base_a; +-- contain subquery +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm03 AS SELECT i,j FROM mv_base_a WHERE i IN (SELECT i FROM mv_base_b WHERE k < 103 ); +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm04 AS SELECT a.i,a.j FROM mv_base_a a, (SELECT * FROM mv_base_b) b WHERE a.i = b.i; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm05 AS SELECT i,j, (SELECT k FROM mv_base_b b WHERE a.i = b.i) FROM mv_base_a a; +-- contain ORDER BY +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm07 AS SELECT i,j,k FROM mv_base_a a INNER JOIN mv_base_b b USING(i) ORDER BY i,j,k; +-- contain HAVING +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm08 AS SELECT i,j,k FROM mv_base_a a INNER JOIN mv_base_b b USING(i) GROUP BY i,j,k HAVING SUM(i) > 5; + +-- contain view or materialized view +CREATE VIEW b_view AS SELECT i,k FROM mv_base_b; +CREATE MATERIALIZED VIEW b_mview AS SELECT i,k FROM mv_base_b; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm07 AS SELECT a.i,a.j FROM mv_base_a a,b_view b WHERE a.i = b.i; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm08 AS SELECT a.i,a.j FROM mv_base_a a,b_mview b WHERE a.i = b.i; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm09 AS SELECT a.i,a.j FROM mv_base_a a, (SELECT i, COUNT(*) FROM mv_base_b GROUP BY i) b WHERE a.i = b.i; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm10 AS SELECT a.i,a.j FROM mv_base_a a WHERE EXISTS(SELECT 1 FROM mv_base_b b WHERE a.i = b.i) OR a.i > 5; + +-- contain mutable functions +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm12 AS SELECT i,j FROM mv_base_a WHERE i = random()::int; + +-- LIMIT/OFFSET is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm13 AS SELECT i,j FROM mv_base_a LIMIT 10 OFFSET 5; + +-- DISTINCT ON is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm14 AS SELECT DISTINCT ON(i) i, j FROM mv_base_a; + +-- TABLESAMPLE clause is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm15 AS SELECT i, j FROM mv_base_a TABLESAMPLE SYSTEM(50); + +-- window functions are not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm16 AS SELECT *, cume_dist() OVER (ORDER BY i) AS rank FROM mv_base_a; + +-- aggregate function with some options is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm17 AS SELECT COUNT(*) FILTER(WHERE i < 3) FROM mv_base_a; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm18 AS SELECT COUNT(DISTINCT i) FROM mv_base_a; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm19 AS SELECT array_agg(j ORDER BY i DESC) FROM mv_base_a; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm20 AS SELECT i,SUM(j) FROM mv_base_a GROUP BY GROUPING SETS((i),()); + +-- inheritance parent is not supported +BEGIN; +CREATE TABLE parent (i int, v int); +CREATE TABLE child_a(options text) INHERITS(parent); +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm21 AS SELECT * FROM parent; +ROLLBACK; + +-- UNION statement is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm22 AS SELECT i,j FROM mv_base_a UNION ALL SELECT i,k FROM mv_base_b;; + +-- empty target list is not allowed with IVM +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm25 AS SELECT FROM mv_base_a; + +-- FOR UPDATE/SHARE is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm26 AS SELECT i,j FROM mv_base_a FOR UPDATE; + +-- tartget list cannot contain ivm column that start with '__ivm' +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm28 AS SELECT i AS "__ivm_count__" FROM mv_base_a; + +-- expressions specified in GROUP BY must appear in the target list. +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm29 AS SELECT COUNT(i) FROM mv_base_a GROUP BY i; + +-- experssions containing an aggregate is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm30 AS SELECT sum(i)*0.5 FROM mv_base_a; +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm31 AS SELECT sum(i)/sum(j) FROM mv_base_a; + +-- VALUES is not supported +CREATE INCREMENTAL MATERIALIZED VIEW mv_ivm_only_values1 AS values(1); + +-- views containing base tables with Row Level Security +DROP USER IF EXISTS ivm_admin; +DROP USER IF EXISTS ivm_user; +CREATE USER ivm_admin; +CREATE USER ivm_user; + +--- create a table with RLS +SET SESSION AUTHORIZATION ivm_admin; +CREATE TABLE rls_tbl(id int, data text, owner name); +INSERT INTO rls_tbl VALUES + (1,'foo','ivm_user'), + (2,'bar','postgres'); +CREATE TABLE num_tbl(id int, num text); +INSERT INTO num_tbl VALUES + (1,'one'), + (2,'two'), + (3,'three'), + (4,'four'), + (5,'five'), + (6,'six'); + +--- Users can access only their own rows +CREATE POLICY rls_tbl_policy ON rls_tbl FOR SELECT TO PUBLIC USING(owner = current_user); +ALTER TABLE rls_tbl ENABLE ROW LEVEL SECURITY; +GRANT ALL on rls_tbl TO PUBLIC; +GRANT ALL on num_tbl TO PUBLIC; + +--- create a view owned by ivm_user +SET SESSION AUTHORIZATION ivm_user; + +CREATE INCREMENTAL MATERIALIZED VIEW ivm_rls AS SELECT * FROM rls_tbl; +SELECT id, data, owner FROM ivm_rls ORDER BY 1,2,3; +RESET SESSION AUTHORIZATION; + +--- inserts rows owned by different users +INSERT INTO rls_tbl VALUES + (3,'baz','ivm_user'), + (4,'qux','postgres'); +SELECT id, data, owner FROM ivm_rls ORDER BY 1,2,3; + +--- combination of diffent kinds of commands +WITH + i AS (INSERT INTO rls_tbl VALUES(5,'quux','postgres'), (6,'corge','ivm_user')), + u AS (UPDATE rls_tbl SET owner = 'postgres' WHERE id = 1), + u2 AS (UPDATE rls_tbl SET owner = 'ivm_user' WHERE id = 2) +SELECT; +SELECT id, data, owner FROM ivm_rls ORDER BY 1,2,3; + +--- +SET SESSION AUTHORIZATION ivm_user; +CREATE INCREMENTAL MATERIALIZED VIEW ivm_rls2 AS SELECT * FROM rls_tbl JOIN num_tbl USING(id); +RESET SESSION AUTHORIZATION; + +WITH + x AS (UPDATE rls_tbl SET data = data || '_2' where id in (3,4)), + y AS (UPDATE num_tbl SET num = num || '_2' where id in (3,4)) +SELECT; +SELECT * FROM ivm_rls2 ORDER BY 1,2,3; + +-- automatic index creation +CREATE TABLE base_a (i int primary key, j int); +CREATE TABLE base_b (i int primary key, j int); + +--- group by: create an index +CREATE INCREMENTAL MATERIALIZED VIEW mv_idx1 AS SELECT i, sum(j) FROM base_a GROUP BY i; + +--- distinct: create an index +CREATE INCREMENTAL MATERIALIZED VIEW mv_idx2 AS SELECT DISTINCT j FROM base_a; + +--- with all pkey columns: create an index +CREATE INCREMENTAL MATERIALIZED VIEW mv_idx3(i_a, i_b) AS SELECT a.i, b.i FROM base_a a, base_b b; + +--- missing some pkey columns: no index +CREATE INCREMENTAL MATERIALIZED VIEW mv_idx4 AS SELECT j FROM base_a; +CREATE INCREMENTAL MATERIALIZED VIEW mv_idx5 AS SELECT a.i, b.j FROM base_a a, base_b b; + +-- cleanup + +DROP TABLE rls_tbl CASCADE; +DROP TABLE num_tbl CASCADE; +DROP USER ivm_user; +DROP USER ivm_admin; + +DROP TABLE mv_base_b CASCADE; +DROP TABLE mv_base_a CASCADE; -- 2.25.1 --Multipart=_Mon__28_Aug_2023_16_05_30_+0900_b1OvQD_3A3ZMTGvj Content-Type: text/x-diff; name="v29-0011-Add-documentations-about-Incremental-View-Mainte.patch" Content-Disposition: attachment; filename="v29-0011-Add-documentations-about-Incremental-View-Mainte.patch" Content-Transfer-Encoding: 7bit ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-06-16 11:54 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-06-16 11:54 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 221 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 160 insertions(+), 110 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index fa98b8b9247..04d39ad8c86 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -93,40 +93,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -173,22 +139,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -197,6 +160,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2613,18 +2579,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2633,7 +2612,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2682,14 +2661,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2705,7 +2684,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2718,7 +2697,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2726,7 +2705,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2735,6 +2714,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2742,16 +2723,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2763,10 +2743,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2794,8 +2774,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2944,10 +2924,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2958,9 +2939,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2968,13 +2949,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -2997,16 +2978,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3077,7 +3058,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3093,41 +3074,65 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); - chgcxt->cc_rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); - InitResultRelInfo(chgcxt->cc_rri, relation, 0, 0, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = (ResultRelInfo *) palloc(sizeof(ResultRelInfo)); + InitResultRelInfo(dest->rri, relation, 0, 0, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3137,12 +3142,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3161,34 +3166,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index f9eb23e52c9..b4d5abbaca7 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2660,6 +2660,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v01-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
* [PATCH 3/8] Introduce RepackDest structure. @ 2026-07-15 08:37 Antonin Houska <ah@cybertec.at> 0 siblings, 0 replies; 604+ messages in thread From: Antonin Houska @ 2026-07-15 08:37 UTC (permalink / raw) This is for ChangeContext to handle insertions into two relations: besides the new relation (whose file will eventually be used by the REPACKed relation), an "auxiliary relation" is needed sometimes, in order to get the data sorted. The concept is introduced and explained later in the patch series. --- src/backend/commands/repack.c | 223 ++++++++++++++++--------------- src/include/commands/repack.h | 48 +++++++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 161 insertions(+), 111 deletions(-) diff --git a/src/backend/commands/repack.c b/src/backend/commands/repack.c index 19927c15bf3..392332b4b2b 100644 --- a/src/backend/commands/repack.c +++ b/src/backend/commands/repack.c @@ -95,40 +95,6 @@ typedef struct Oid indexOid; } RelToCluster; -/* - * The first file exported by the decoding worker must contain a snapshot, the - * following ones contain the data changes. - */ -#define WORKER_FILE_SNAPSHOT 0 - -/* - * Information needed to apply concurrent data changes. - */ -typedef struct ChangeContext -{ - /* The relation the changes are applied to. */ - Relation cc_rel; - - /* Needed to update indexes of cc_rel. */ - ResultRelInfo *cc_rri; - EState *cc_estate; - - /* - * Existing tuples to UPDATE and DELETE are located via this index. We - * keep the scankey in partially initialized state to avoid repeated work. - * sk_argument is completed on the fly. - */ - Relation cc_ident_index; - ScanKey cc_ident_key; - int cc_ident_key_nentries; - - /* The latest column we need to deform to have the tuple identity */ - AttrNumber cc_last_key_attno; - - /* Sequential number of the file containing the changes. */ - int cc_file_seq; -} ChangeContext; - /* * Backend-local information to control the decoding worker. */ @@ -175,22 +141,19 @@ static List *get_tables_to_repack_partitioned(RepackCommand cmd, static bool repack_is_permitted_for_relation(RepackCommand cmd, Oid relid, Oid userid); -static void apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt); -static void apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt); -static void apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt); +static void apply_concurrent_changes(ChangeContext *chgcxt); +static void apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot); +static void apply_concurrent_update(RepackDest *dest, + TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple); static void apply_concurrent_delete(Relation rel, TupleTableSlot *slot); static void restore_tuple(BufFile *file, Relation relation, TupleTableSlot *slot); static void adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *src); -static bool find_target_tuple(Relation rel, ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved); -static bool identity_key_equal(ChangeContext *chgcxt, - TupleTableSlot *locator, +static bool identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate); static void process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, @@ -199,6 +162,9 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id); static void release_change_context(ChangeContext *chgcxt); +static void initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id); +static void release_change_dest(RepackDest *dest); static void rebuild_relation_finish_concurrent(Relation NewHeap, Relation OldHeap, Oid identIdx, TransactionId frozenXid, @@ -2614,18 +2580,31 @@ RepackCommandAsString(RepackCommand cmd) } /* - * Apply all the changes stored in 'file'. + * Apply all the changes provided by decoding worker. */ static void -apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) +apply_concurrent_changes(ChangeContext *chgcxt) { ConcurrentChangeKind kind = '\0'; - Relation rel = chgcxt->cc_rel; + RepackDest *dest; + Relation rel; TupleTableSlot *spilled_tuple; TupleTableSlot *old_update_tuple; TupleTableSlot *ondisk_tuple; bool have_old_tuple = false; MemoryContext oldcxt; + DecodingWorkerShared *shared; + char fname[MAXPGPATH]; + BufFile *file; + + dest = &chgcxt->cc_dest; + rel = dest->rel; + + shared = (DecodingWorkerShared *) dsm_segment_address(decoding_worker->seg); + + /* Open the file containing the changes. */ + DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); + file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); spilled_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); @@ -2634,7 +2613,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) old_update_tuple = MakeSingleTupleTableSlot(RelationGetDescr(rel), &TTSOpsVirtual); - oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(chgcxt->cc_estate)); + oldcxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(dest->estate)); while (true) { @@ -2683,14 +2662,14 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) if (kind == CHANGE_INSERT) { - apply_concurrent_insert(rel, spilled_tuple, chgcxt); + apply_concurrent_insert(dest, spilled_tuple); } else if (kind == CHANGE_DELETE) { bool found; /* Find the tuple to be deleted */ - found = find_target_tuple(rel, chgcxt, spilled_tuple, ondisk_tuple); + found = find_target_tuple(dest, spilled_tuple, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); apply_concurrent_delete(rel, ondisk_tuple); @@ -2706,7 +2685,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) key = spilled_tuple; /* Find the tuple to be updated or deleted. */ - found = find_target_tuple(rel, chgcxt, key, ondisk_tuple); + found = find_target_tuple(dest, key, ondisk_tuple); if (!found) elog(ERROR, "could not find target tuple"); @@ -2719,7 +2698,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) */ adjust_toast_pointers(rel, spilled_tuple, ondisk_tuple); - apply_concurrent_update(rel, spilled_tuple, ondisk_tuple, chgcxt); + apply_concurrent_update(dest, spilled_tuple, ondisk_tuple); ExecClearTuple(old_update_tuple); have_old_tuple = false; @@ -2727,7 +2706,7 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) else elog(ERROR, "unrecognized kind of change: %d", kind); - ResetPerTupleExprContext(chgcxt->cc_estate); + ResetPerTupleExprContext(dest->estate); } /* Cleanup. */ @@ -2736,6 +2715,8 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) ExecDropSingleTupleTableSlot(old_update_tuple); MemoryContextSwitchTo(oldcxt); + + BufFileClose(file); } /* @@ -2743,16 +2724,15 @@ apply_concurrent_changes(BufFile *file, ChangeContext *chgcxt) * table. */ static void -apply_concurrent_insert(Relation rel, TupleTableSlot *slot, - ChangeContext *chgcxt) +apply_concurrent_insert(RepackDest *dest, TupleTableSlot *slot) { /* Put the tuple in the table, but make sure it won't be decoded */ - table_tuple_insert(rel, slot, GetCurrentCommandId(true), + table_tuple_insert(dest->rel, slot, GetCurrentCommandId(true), TABLE_INSERT_NO_LOGICAL, NULL); /* Update indexes with this new tuple. */ - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, 0, slot, NIL, NULL); @@ -2764,10 +2744,10 @@ apply_concurrent_insert(Relation rel, TupleTableSlot *slot, * table. */ static void -apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, - TupleTableSlot *ondisk_tuple, - ChangeContext *chgcxt) +apply_concurrent_update(RepackDest *dest, TupleTableSlot *spilled_tuple, + TupleTableSlot *ondisk_tuple) { + Relation rel = dest->rel; LockTupleMode lockmode; TM_FailureData tmfd; TU_UpdateIndexes update_indexes; @@ -2795,8 +2775,8 @@ apply_concurrent_update(Relation rel, TupleTableSlot *spilled_tuple, if (update_indexes == TU_Summarizing) flags |= EIIT_ONLY_SUMMARIZING; - ExecInsertIndexTuples(chgcxt->cc_rri, - chgcxt->cc_estate, + ExecInsertIndexTuples(dest->rri, + dest->estate, flags, spilled_tuple, NIL, NULL); @@ -2948,10 +2928,11 @@ adjust_toast_pointers(Relation relation, TupleTableSlot *dest, TupleTableSlot *s * not found, return false. */ static bool -find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, +find_target_tuple(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *retrieved) { - Form_pg_index idx = chgcxt->cc_ident_index->rd_index; + Relation rel = dest->rel; + Form_pg_index idx = dest->ident_index->rd_index; IndexScanDesc scan; bool retval = false; @@ -2962,9 +2943,9 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * * Use the incoming tuple to finalize the scan key. */ - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; + ScanKey entry = &dest->ident_key[i]; AttrNumber attno = idx->indkey.values[i]; entry->sk_argument = locator->tts_values[attno - 1]; @@ -2972,13 +2953,13 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, } /* XXX no instrumentation for now */ - scan = index_beginscan(rel, chgcxt->cc_ident_index, GetActiveSnapshot(), - NULL, chgcxt->cc_ident_key_nentries, 0, 0); - index_rescan(scan, chgcxt->cc_ident_key, chgcxt->cc_ident_key_nentries, NULL, 0); + scan = index_beginscan(rel, dest->ident_index, GetActiveSnapshot(), + NULL, dest->ident_key_nentries, 0, 0); + index_rescan(scan, dest->ident_key, dest->ident_key_nentries, NULL, 0); while (index_getnext_slot(scan, ForwardScanDirection, retrieved)) { /* Be wary of temporal constraints */ - if (scan->xs_recheck && !identity_key_equal(chgcxt, locator, retrieved)) + if (scan->xs_recheck && !identity_key_equal(dest, locator, retrieved)) { CHECK_FOR_INTERRUPTS(); continue; @@ -3001,16 +2982,16 @@ find_target_tuple(Relation rel, ChangeContext *chgcxt, TupleTableSlot *locator, * used for temporal constraints. */ static bool -identity_key_equal(ChangeContext *chgcxt, TupleTableSlot *locator, +identity_key_equal(RepackDest *dest, TupleTableSlot *locator, TupleTableSlot *candidate) { - slot_getsomeattrs(locator, chgcxt->cc_last_key_attno); - slot_getsomeattrs(candidate, chgcxt->cc_last_key_attno); + slot_getsomeattrs(locator, dest->last_key_attno); + slot_getsomeattrs(candidate, dest->last_key_attno); - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + for (int i = 0; i < dest->ident_key_nentries; i++) { - ScanKey entry = &chgcxt->cc_ident_key[i]; - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + ScanKey entry = &dest->ident_key[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); @@ -3081,7 +3062,7 @@ process_concurrent_changes(XLogRecPtr end_of_wal, ChangeContext *chgcxt, bool do /* Open the file. */ DecodingWorkerFileName(fname, shared->relid, chgcxt->cc_file_seq); file = BufFileOpenFileSet(&shared->sfs.fs, fname, O_RDONLY, false); - apply_concurrent_changes(file, chgcxt); + apply_concurrent_changes(chgcxt); BufFileClose(file); @@ -3097,10 +3078,34 @@ static void initialize_change_context(ChangeContext *chgcxt, Relation relation, Oid ident_index_id) { - chgcxt->cc_rel = relation; + initialize_change_dest(&chgcxt->cc_dest, relation, ident_index_id); + + chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; +} + +/* + * Free up resources taken by a ChangeContext. + */ +static void +release_change_context(ChangeContext *chgcxt) +{ + release_change_dest(&chgcxt->cc_dest); +} + +/* + * Initialize the RepackDest struct for the given relation, with the given + * index as identity index. InvalidOid can be specified to only make the + * relation ready for insertions. + */ +static void +initialize_change_dest(RepackDest *dest, Relation relation, + Oid ident_index_id) +{ + dest->rel = relation; + dest->bistate = GetBulkInsertState(); /* Only initialize fields needed by ExecInsertIndexTuples(). */ - chgcxt->cc_estate = CreateExecutorState(); + dest->estate = CreateExecutorState(); /* * Set up a range table for the executor, containing our repacked table as @@ -3149,41 +3154,41 @@ initialize_change_context(ChangeContext *chgcxt, perminfo->updatedCols = updatedCols; /* finally we can initialize the range table proper */ - ExecInitRangeTable(chgcxt->cc_estate, list_make1(rte), perminfos, + ExecInitRangeTable(dest->estate, list_make1(rte), perminfos, bms_make_singleton(1)); } /* Set up our ResultRelInfo to use for index updates */ - chgcxt->cc_rri = makeNode(ResultRelInfo); - InitResultRelInfo(chgcxt->cc_rri, relation, 1, NULL, 0); - ExecOpenIndices(chgcxt->cc_rri, false); + dest->rri = makeNode(ResultRelInfo); + InitResultRelInfo(dest->rri, relation, 1, NULL, 0); + ExecOpenIndices(dest->rri, false); /* * The table's relcache entry already has the relcache entry for the * identity index; find that. */ - chgcxt->cc_ident_index = NULL; - for (int i = 0; i < chgcxt->cc_rri->ri_NumIndices; i++) + dest->ident_index = NULL; + for (int i = 0; i < dest->rri->ri_NumIndices; i++) { Relation ind_rel; - ind_rel = chgcxt->cc_rri->ri_IndexRelationDescs[i]; + ind_rel = dest->rri->ri_IndexRelationDescs[i]; if (ind_rel->rd_id == ident_index_id) { - chgcxt->cc_ident_index = ind_rel; + dest->ident_index = ind_rel; break; } } - if (chgcxt->cc_ident_index == NULL) + if (dest->ident_index == NULL) elog(ERROR, "could not find identity index"); /* Set up for scanning said identity index */ { Form_pg_index indexForm; - indexForm = chgcxt->cc_ident_index->rd_index; - chgcxt->cc_ident_key_nentries = indexForm->indnkeyatts; - chgcxt->cc_ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); + indexForm = dest->ident_index->rd_index; + dest->ident_key_nentries = indexForm->indnkeyatts; + dest->ident_key = (ScanKey) palloc_array(ScanKeyData, indexForm->indnkeyatts); for (int i = 0; i < indexForm->indnkeyatts; i++) { ScanKey entry; @@ -3193,12 +3198,12 @@ initialize_change_context(ChangeContext *chgcxt, opcode; StrategyNumber eq_strategy; - entry = &chgcxt->cc_ident_key[i]; + entry = &dest->ident_key[i]; - opfamily = chgcxt->cc_ident_index->rd_opfamily[i]; - opcintype = chgcxt->cc_ident_index->rd_opcintype[i]; + opfamily = dest->ident_index->rd_opfamily[i]; + opcintype = dest->ident_index->rd_opcintype[i]; eq_strategy = IndexAmTranslateCompareType(COMPARE_EQ, - chgcxt->cc_ident_index->rd_rel->relam, + dest->ident_index->rd_rel->relam, opfamily, false); if (eq_strategy == InvalidStrategy) elog(ERROR, "could not find equality strategy for index operator family %u for type %u", @@ -3217,34 +3222,30 @@ initialize_change_context(ChangeContext *chgcxt, i + 1, eq_strategy, opcode, (Datum) 0); - entry->sk_collation = chgcxt->cc_ident_index->rd_indcollation[i]; + entry->sk_collation = dest->ident_index->rd_indcollation[i]; } } /* Determine the last column we must deform to read the identity */ - chgcxt->cc_last_key_attno = InvalidAttrNumber; - for (int i = 0; i < chgcxt->cc_ident_key_nentries; i++) + dest->last_key_attno = InvalidAttrNumber; + for (int i = 0; i < dest->ident_key_nentries; i++) { - AttrNumber attno = chgcxt->cc_ident_index->rd_index->indkey.values[i]; + AttrNumber attno = dest->ident_index->rd_index->indkey.values[i]; Assert(attno > 0); - chgcxt->cc_last_key_attno = Max(chgcxt->cc_last_key_attno, attno); + dest->last_key_attno = Max(dest->last_key_attno, attno); } - - chgcxt->cc_file_seq = WORKER_FILE_SNAPSHOT + 1; } -/* - * Free up resources taken by a ChangeContext. - */ static void -release_change_context(ChangeContext *chgcxt) +release_change_dest(RepackDest *dest) { - ExecCloseIndices(chgcxt->cc_rri); - FreeExecutorState(chgcxt->cc_estate); + FreeBulkInsertState(dest->bistate); + ExecCloseIndices(dest->rri); + FreeExecutorState(dest->estate); /* XXX are these pfrees necessary? */ - pfree(chgcxt->cc_rri); - pfree(chgcxt->cc_ident_key); + pfree(dest->rri); + pfree(dest->ident_key); } /* diff --git a/src/include/commands/repack.h b/src/include/commands/repack.h index 27105c10591..07f887e99f6 100644 --- a/src/include/commands/repack.h +++ b/src/include/commands/repack.h @@ -16,6 +16,7 @@ #include <signal.h> #include "access/hio.h" +#include "access/skey.h" #include "nodes/execnodes.h" #include "nodes/parsenodes.h" #include "parser/parse_node.h" @@ -39,6 +40,53 @@ typedef struct ClusterParams extern PGDLLIMPORT volatile sig_atomic_t RepackMessagePending; +/* + * Table to apply concurrent data changes to. + */ +typedef struct RepackDest +{ + /* The relation the changes are applied to. */ + Relation rel; + + BulkInsertStateData *bistate; + + /* Needed to update indexes of cc_rel. */ + ResultRelInfo *rri; + EState *estate; + + /* + * Existing tuples to UPDATE and DELETE are located via this index. We + * keep the scankey in partially initialized state to avoid repeated work. + * sk_argument is completed on the fly. + */ + Relation ident_index; + ScanKey ident_key; + + int ident_key_nentries; + + /* The latest column we need to deform to have the tuple identity */ + AttrNumber last_key_attno; +} RepackDest; + +/* + * The first file exported by the decoding worker must contain a snapshot, the + * following ones contain the data changes. + */ +#define WORKER_FILE_SNAPSHOT 0 + +/* + * Information needed to apply concurrent data changes. + * + * XXX Now that it's in *.h file, rename to RepackChangeContext? + */ +typedef struct ChangeContext +{ + /* The destination table. */ + RepackDest cc_dest; + + /* Sequential number of the file containing the changes. */ + int cc_file_seq; +} ChangeContext; extern void ExecRepack(ParseState *pstate, RepackStmt *stmt, bool isTopLevel); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 56c1f997f88..25ac7079099 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -2664,6 +2664,7 @@ ReorderBufferTupleCidKey ReorderBufferUpdateProgressTxnCB ReorderTuple RepackCommand +RepackDest RepackDecodingState RepackStmt ReparameterizeForeignPathByChild_function -- 2.52.0 --=-=-= Content-Type: text/plain Content-Disposition: attachment; filename=v02-0004-Use-multiple-snapshots-to-copy-the-data.patch ^ permalink raw reply [nested|flat] 604+ messages in thread
end of thread, other threads:[~2026-07-15 08:37 UTC | newest] Thread overview: 604+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2021-03-10 02:11 [PATCH v29 10/11] Add regression tests for Incremental View Maintenance Takuma Hoshiai <takuma.hoshiai@gmail.com> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-06-16 11:54 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at> 2026-07-15 08:37 [PATCH 3/8] Introduce RepackDest structure. Antonin Houska <ah@cybertec.at>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox